In [1]:
import sys
import os
sys.path.insert(0, os.path.abspath('../'))
sys.path.insert(0, os.path.abspath('../../'))
sys.path.insert(0, os.path.abspath('/home/hm-tlacherm/qlm_notebooks/notebooks_1.2.1/notebooks/master_thesis_qaoa/'))
sys.path.insert(0, os.path.abspath('/home/hm-tlacherm/qlm_notebooks/notebooks_1.2.1/notebooks/master_thesis_qaoa/ibm/'))
sys.path.insert(0, os.path.abspath('/home/hm-tlacherm/qlm_notebooks/notebooks_1.2.1/notebooks/master_thesis_qaoa/aqt/'))
In [2]:
import numpy as np

import qiskit
provider = qiskit.IBMQ.load_account()

from qiskit_aqt_provider import AQTProvider
aqt = AQTProvider('6f47670f3e5c414da0cdcab1c048eb97')
simulator_backend =  aqt.backends.aqt_qasm_simulator_noise_1

from qiskit import Aer
from qiskit.utils import QuantumInstance
from qiskit_optimization.algorithms import MinimumEigenOptimizer
from qiskit.algorithms import QAOA
from shared.QiskitMaxcut import *
from ibm.ibm_parameters import *
from matplotlib import pyplot as plt
%matplotlib inline
In [3]:
%load_ext autoreload
%autoreload 2
In [4]:
# ---- Define graph and MaxCut ----
graph = generate_butterfly_graph(with_weights=True)
max_cut = Maxcut(graph)
max_cut_qubo = max_cut.to_qubo()
max_cut.draw()
In [5]:
# ---- Define step size and gamma, beta values ----
step_size = 0.1
a_gamma = np.arange(0, np.pi, step_size)
b_beta = np.arange(0, np.pi, step_size)
In [6]:
gammas, betas = np.meshgrid(a_gamma, b_beta)
In [7]:
def run_qaoa(gamma, beta):
    qaoa = QAOA(optimizer=COBYLA(maxiter=0),
                quantum_instance=simulator_backend,
                reps=1,
                initial_point=[gamma, beta])
    algorithm = MinimumEigenOptimizer(qaoa)
    result = algorithm.solve(max_cut_qubo)
    optimal_parameters = qaoa.optimal_params
    mean, distribution = max_cut.analyse(result)

    return mean
In [8]:
# ---- execute for all values QAOA and get result matrix  ----
landscape = np.zeros(gammas.shape)
for i in range(0, len(landscape)):
    for j in range(0, len(landscape)):
        landscape[i,j] = run_qaoa(gammas[i][j], betas[i][j])
    print(f"Row {i} done")

Row 0 done
Row 1 done
Row 2 done
Row 3 done
Row 4 done
Row 5 done
Row 6 done
Row 7 done
Row 8 done
Row 9 done
Row 10 done
Row 11 done
Row 12 done
Row 13 done
Row 14 done
Row 15 done
Row 16 done
Row 17 done
Row 18 done
Row 19 done
Row 20 done
Row 21 done
Row 22 done
Row 23 done
Row 24 done
Row 25 done
Row 26 done
Row 27 done
Row 28 done
Row 29 done
Row 30 done
Row 31 done
In [9]:
print(landscape)
plt.matshow(landscape)
plt.show()

[[-24.15 -23.09 -22.26 ... -22.99 -22.58 -22.78]
 [-26.82 -23.33 -19.39 ... -29.32 -28.87 -25.83]
 [-24.31 -24.6  -24.47 ... -22.45 -22.09 -23.8 ]
 ...
 [-23.19 -24.07 -25.46 ... -24.77 -23.87 -23.27]
 [-24.67 -23.43 -22.87 ... -22.96 -24.76 -23.99]
 [-23.45 -24.95 -24.5  ... -23.09 -23.2  -22.38]]
In [10]:
# Mean of landscape
np.mean(landscape)
Out[10]:
-23.611972656250003
In [11]:
# Minimium 
np.min(landscape)
Out[11]:
-31.81
In [12]:
# Display Coordinates of Minimum 
np.unravel_index(np.argmin(landscape), landscape.shape)
Out[12]:
(15, 6)
In [13]:
# Gamma and beta value of Minimium
gamma, beta = np.unravel_index(np.argmin(landscape), landscape.shape)
opt_gamma = gamma * step_size
opt_beta = beta * step_size
print(f"Opt.Gamma: {opt_gamma}, Opt.Beta: {opt_beta}")

Opt.Gamma: 1.5, Opt.Beta: 0.6000000000000001
In [14]:
# Save result matrix 
with open('landscape_noise_simulator_butterfly_weights_results.npy', 'wb') as f:
    np.save(f, landscape)
In [15]:
import plotly.graph_objects as go
In [16]:
# Plot landscape in 3D 
a_gamma = np.arange(0, np.pi, step_size)
b_beta = np.arange(0, np.pi, step_size)
fig = go.Figure(data=go.Surface(z=landscape, x=a_gamma, y=b_beta))

fig.update_traces(contours_z=dict(show=True, usecolormap=True, highlightcolor='limegreen', project_z=True))


fig.update_layout(title="QAOA MaxCut", scene=dict(
    xaxis_title="gamma",
    yaxis_title="beta",
    zaxis_title="mean"
))
In [17]:
# Plot Heatmap 
fig = go.Figure(data=go.Heatmap(z=landscape, x=b_beta, y=a_gamma, type = 'heatmap', colorscale = 'viridis'))

# Update Layout
fig.update_layout(title="QAOA MaxCut", width=700, height=700, xaxis_title="beta", yaxis_title="gamma")

# Display Global Minimium 
fig.add_trace(
    go.Scatter(mode="markers", x=[opt_beta], y=[opt_gamma], marker_symbol=[204], text = [landscape[gamma,beta]],
                   marker_color="red",  hovertemplate="x: %{x}<br>y: %{y}<br> z: %{text:.2f}<extra></extra>", 
                   marker_line_width=1, marker_size=16))
In [18]:
# Display Optimizer Results

# Display path 
#fig.add_trace(
#    go.Scatter(mode="lines", x=gammas, y=betas, marker_symbol=[200],
#                   marker_color="white", marker_line_width=1, marker_size=8)
#)

# Display start point
#fig.add_trace(
#    go.Scatter(mode="markers", x=[gammas[0]], y=[betas[0]], marker_symbol=[204],
#                   marker_color="gray", 
#                   marker_line_width=1, marker_size=16))

# Display end point
#fig.add_trace(
#    go.Scatter(mode="markers", x=[gammas[-1]], y=[betas[-1]], marker_symbol=[204],
#                   marker_color="green", 
#                   marker_line_width=1, marker_size=16))
In [19]:
# Plot Optimizer History
#fig = go.Figure(data=go.Scatter(x=counts, y=values))
#fig.update_layout(xaxis_title="Evaluation Counts", yaxis_title="Evaluated Mean", title="Optimizer")
#fig.show()